{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuration for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(600, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 01. A2C\n",
    "[Mnih, Volodymyr, et al. \"Asynchronous methods for deep reinforcement learning.\" International conference on machine learning. 2016.](http://proceedings.mlr.press/v48/mniha16.pdf)\n",
    "\n",
    "### Actor-Critic\n",
    "\n",
    "*Actor critic* method is one of the popular *policy optimization* algorithms. This approach maximizes the expected return by pushing up the probabilities of actions that receive higher returns. Let $\\pi_\\theta$ denote a policy with parameters $\\theta$. The policy gradient of performance $\\mathcal{J}(\\pi_\\theta)$ is\n",
    "\n",
    "$$ \\nabla_\\theta \\mathcal{J}(\\pi_\\theta) = \\underset{\\tau\\sim\\pi_\\theta}{\\mathbb{E}}\\left[ \\sum^T_{t=0} \\nabla_\\theta \\log \\pi_\\theta(a_t|s_t)A^{\\pi_\\theta}(s_t, a_t) \\right],$$\n",
    "\n",
    "where $\\tau$ is a trajectory and $A^{\\pi_\\theta}$ is the advantage function for reducing variance of values. The *policy gradient algorithm* updates the parameters by adding this gradient.\n",
    "\n",
    "$$\\theta_{k+1} = \\theta_k + \\alpha \\nabla_\\theta \\mathcal{J}(\\pi_{\\theta_k}),$$\n",
    "\n",
    "where $\\alpha$ is a learning rate. The agent is trained in an on-policy way because the parameters are updated by the current policy. We call the policy *Actor* which predicts probabilities of actions in each state, and call the value function *Critic* that predicts values of all state-action pairs. \n",
    "\n",
    "\n",
    "### Advantage Function\n",
    "\n",
    "The advantage function effectively reduces the variance of values and is defined as follows.\n",
    "\n",
    "$$ A(s,a) = Q(s,a) - V(s) $$\n",
    "\n",
    "From this formula, we can replace Q with $r+\\gamma V(s')$ and redefine Advantage function without using Action-Value function.\n",
    "\n",
    "$$ A(s,a) = r + \\gamma V(s') - V(s) $$\n",
    "\n",
    "\n",
    "### Maximization Entropy\n",
    "\n",
    "Entropy is a measure of unpredictability or a measure of randomness. If we have actions with almost equal probabilities, the entropy over the actions will be the largest because it's completely unpredictable which action will be chosen. In view of the fact, we can encourage exploration by adding entropy maximization term to the loss function. The entropy $H$ with respect to the probability $p$ over actions is\n",
    "\n",
    "$$ H(P) = - \\sum_a p(a) \\log p(a) $$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## import module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from typing import List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "from torch.distributions import Normal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.backends.cudnn.enabled:\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "\n",
    "seed = 777\n",
    "torch.manual_seed(seed)\n",
    "np.random.seed(seed)\n",
    "random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "We will use two separated networks for actor and critic respectively. The actor network consists of one fully connected hidden layer with ReLU branched out two fully connected output layers for mean and standard deviation of Normal distribution. Pendulum-v0 has only one action which has a range from -2 to 2. In order to fit the range, the actor outputs the mean value that is multiplied by 2 after tanh. On the one hand, the critic network has two fully connected layers as a hidden layer (ReLU) and an output layer. One thing to note is that we initialize the last layers' weights and biases as uniformly distributed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_uniformly(layer: nn.Linear, init_w: float = 3e-3):\n",
    "    \"\"\"Initialize the weights and bias in [-init_w, init_w].\"\"\"\n",
    "    layer.weight.data.uniform_(-init_w, init_w)\n",
    "    layer.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "\n",
    "class Actor(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Actor, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.mu_layer = nn.Linear(128, out_dim)     \n",
    "        self.log_std_layer = nn.Linear(128, out_dim)   \n",
    "        \n",
    "        initialize_uniformly(self.mu_layer)\n",
    "        initialize_uniformly(self.log_std_layer)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden1(state))\n",
    "        \n",
    "        mu = torch.tanh(self.mu_layer(x)) * 2\n",
    "        log_std = F.softplus(self.log_std_layer(x))\n",
    "        std = torch.exp(log_std)\n",
    "        \n",
    "        dist = Normal(mu, std)\n",
    "        action = dist.sample()\n",
    "        \n",
    "        return action, dist\n",
    "    \n",
    "class Critic(nn.Module):\n",
    "    def __init__(self, in_dim: int):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Critic, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.out = nn.Linear(128, 1)\n",
    "        \n",
    "        initialize_uniformly(self.out)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden1(state))\n",
    "        value = self.out(x)\n",
    "        \n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A2C Agent\n",
    "Here is a summary of A2CAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "|---               |---                                                   |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A2CAgent:\n",
    "    \"\"\"A2CAgent interacting with environment.\n",
    "        \n",
    "    Atribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        gamma (float): discount factor\n",
    "        entropy_weight (float): rate of weighting entropy into the loss function\n",
    "        device (torch.device): cpu / gpu\n",
    "        actor (nn.Module): target actor model to select actions\n",
    "        critic (nn.Module): critic model to predict state values\n",
    "        actor_optimizer (optim.Optimizer) : optimizer of actor\n",
    "        critic_optimizer (optim.Optimizer) : optimizer of critic\n",
    "        transition (list): temporory storage for the recent transition\n",
    "        total_step (int): total step numbers\n",
    "        is_test (bool): flag to show the current mode (train / test)\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, env: gym.Env, gamma: float, entropy_weight: float):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        self.env = env\n",
    "        self.gamma = gamma\n",
    "        self.entropy_weight = entropy_weight\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "        \n",
    "        # networks\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.shape[0]\n",
    "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.critic = Critic(obs_dim).to(self.device)\n",
    "        \n",
    "        # optimizer\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=1e-4)\n",
    "        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=1e-3)\n",
    "        \n",
    "        # transition (state, log_prob, next_state, reward, done)\n",
    "        self.transition: list = list()\n",
    "        \n",
    "        # total steps count\n",
    "        self.total_step = 0\n",
    "\n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "        \n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        state = torch.FloatTensor(state).to(self.device)\n",
    "        action, dist = self.actor(state)\n",
    "        selected_action = dist.mean if self.is_test else action\n",
    "\n",
    "        if not self.is_test:\n",
    "            log_prob = dist.log_prob(selected_action).sum(dim=-1)\n",
    "            self.transition = [state, log_prob]\n",
    "        \n",
    "        return selected_action.clamp(-2.0, 2.0).cpu().detach().numpy()\n",
    "    \n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition.extend([next_state, reward, done])           \n",
    "    \n",
    "        return next_state, reward, done\n",
    "    \n",
    "    def update_model(self) -> Tuple[torch.Tensor, torch.Tensor]:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"  \n",
    "        state, log_prob, next_state, reward, done = self.transition\n",
    "\n",
    "        # Q_t   = r + gamma * V(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        mask = 1 - done\n",
    "        next_state = torch.FloatTensor(next_state).to(self.device)\n",
    "        pred_value = self.critic(state)\n",
    "        targ_value = reward + self.gamma * self.critic(next_state) * mask\n",
    "        value_loss = F.smooth_l1_loss(pred_value, targ_value.detach())\n",
    "        \n",
    "        # update value\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        value_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "\n",
    "        # advantage = Q_t - V(s_t)\n",
    "        advantage = (targ_value - pred_value).detach()  # not backpropagated\n",
    "        policy_loss = -advantage * log_prob\n",
    "        policy_loss += self.entropy_weight * -log_prob  # entropy maximization\n",
    "\n",
    "        # update policy\n",
    "        self.actor_optimizer.zero_grad()\n",
    "        policy_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "\n",
    "        return policy_loss.item(), value_loss.item()\n",
    "    \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        actor_losses, critic_losses, scores = [], [], []\n",
    "        state = self.env.reset()\n",
    "        score = 0\n",
    "        \n",
    "        for self.total_step in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "            \n",
    "            actor_loss, critic_loss = self.update_model()\n",
    "            actor_losses.append(actor_loss)\n",
    "            critic_losses.append(critic_loss)\n",
    "            \n",
    "            state = next_state\n",
    "            score += reward\n",
    "            \n",
    "            # if episode ends\n",
    "            if done:         \n",
    "                state = env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0                \n",
    "            \n",
    "            # plot\n",
    "            if self.total_step % plotting_interval == 0:\n",
    "                self._plot(self.total_step, scores, actor_losses, critic_losses)\n",
    "        self.env.close()\n",
    "    \n",
    "    def test(self):\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        return frames\n",
    "    \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        actor_losses: List[float], \n",
    "        critic_losses: List[float], \n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        def subplot(loc: int, title: str, values: List[float]):\n",
    "            plt.subplot(loc)\n",
    "            plt.title(title)\n",
    "            plt.plot(values)\n",
    "\n",
    "        subplot_params = [\n",
    "            (131, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
    "            (132, \"actor_loss\", actor_losses),\n",
    "            (133, \"critic_loss\", critic_losses),\n",
    "        ]\n",
    "\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(30, 5))\n",
    "        for loc, title, values in subplot_params:\n",
    "            subplot(loc, title, values)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see [the code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/pendulum.py) and [configurations](https://github.com/openai/gym/blob/cedecb35e3428985fd4efad738befeb75b9077f1/gym/envs/__init__.py#L81) of Pendulum-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "env_id = \"Pendulum-v0\"\n",
    "env = gym.make(env_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "num_frames = 100000\n",
    "gamma = 0.9\n",
    "entropy_weight = 1e-2\n",
    "\n",
    "agent = A2CAgent(env, gamma, entropy_weight)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  -135.17415452820998\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "if IN_COLAB:\n",
    "    agent.env = gym.wrappers.Monitor(agent.env, \"videos\", force=True)\n",
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgCCKTXUBQDPLJZZXF\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderCCKTXUBQDPLJZZXF\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animCCKTXUBQDPLJZZXF.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animCCKTXUBQDPLJZZXF.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animCCKTXUBQDPLJZZXF.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animCCKTXUBQDPLJZZXF.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animCCKTXUBQDPLJZZXF.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animCCKTXUBQDPLJZZXF.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animCCKTXUBQDPLJZZXF.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animCCKTXUBQDPLJZZXF.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animCCKTXUBQDPLJZZXF.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animCCKTXUBQDPLJZZXF.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectCCKTXUBQDPLJZZXF\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgCCKTXUBQDPLJZZXF\";\n",
       "    var slider_id = \"_anim_sliderCCKTXUBQDPLJZZXF\";\n",
       "    var loop_select_id = \"_anim_loop_selectCCKTXUBQDPLJZZXF\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "  frames[157] = \"\"\n",
       "  frames[158] = \"\"\n",
       "  frames[159] = \"\"\n",
       "  frames[160] = \"\"\n",
       "  frames[161] = \"\"\n",
       "  frames[162] = \"\"\n",
       "  frames[163] = \"\"\n",
       "  frames[164] = \"\"\n",
       "  frames[165] = \"\"\n",
       "  frames[166] = \"\"\n",
       "  frames[167] = \"\"\n",
       "  frames[168] = \"\"\n",
       "  frames[169] = \"\"\n",
       "  frames[170] = \"\"\n",
       "  frames[171] = \"\"\n",
       "  frames[172] = \"\"\n",
       "  frames[173] = \"\"\n",
       "  frames[174] = \"\"\n",
       "  frames[175] = \"\"\n",
       "  frames[176] = \"\"\n",
       "  frames[177] = \"\"\n",
       "  frames[178] = \"\"\n",
       "  frames[179] = \"\"\n",
       "  frames[180] = \"\"\n",
       "  frames[181] = \"\"\n",
       "  frames[182] = \"\"\n",
       "  frames[183] = \"\"\n",
       "  frames[184] = \"\"\n",
       "  frames[185] = \"\"\n",
       "  frames[186] = \"\"\n",
       "  frames[187] = \"\"\n",
       "  frames[188] = \"\"\n",
       "  frames[189] = \"\"\n",
       "  frames[190] = \"\"\n",
       "  frames[191] = \"\"\n",
       "  frames[192] = \"\"\n",
       "  frames[193] = \"\"\n",
       "  frames[194] = \"\"\n",
       "  frames[195] = \"\"\n",
       "  frames[196] = \"\"\n",
       "  frames[197] = \"\"\n",
       "  frames[198] = \"\"\n",
       "  frames[199] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animCCKTXUBQDPLJZZXF = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if IN_COLAB:  # for colab\n",
    "    import base64\n",
    "    import glob\n",
    "    import io\n",
    "    import os\n",
    "\n",
    "    from IPython.display import HTML, display\n",
    "\n",
    "    def ipython_show_video(path: str) -> None:\n",
    "        \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "        if not os.path.isfile(path):\n",
    "            raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "        video = io.open(path, \"r+b\").read()\n",
    "        encoded = base64.b64encode(video)\n",
    "\n",
    "        display(HTML(\n",
    "            data=\"\"\"\n",
    "            <video alt=\"test\" controls>\n",
    "            <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "            </video>\n",
    "            \"\"\".format(encoded.decode(\"ascii\"))\n",
    "        ))\n",
    "\n",
    "    list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    print(latest_file)\n",
    "    ipython_show_video(latest_file)\n",
    "\n",
    "else:  # for jupyter\n",
    "    from matplotlib import animation\n",
    "    from JSAnimation.IPython_display import display_animation\n",
    "    from IPython.display import display\n",
    "\n",
    "\n",
    "    def display_frames_as_gif(frames):\n",
    "        \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "        patch = plt.imshow(frames[0])\n",
    "        plt.axis('off')\n",
    "\n",
    "        def animate(i):\n",
    "            patch.set_data(frames[i])\n",
    "\n",
    "        anim = animation.FuncAnimation(\n",
    "            plt.gcf(), animate, frames = len(frames), interval=50\n",
    "        )\n",
    "        display(display_animation(anim, default_mode='loop'))\n",
    "\n",
    "\n",
    "    # display \n",
    "    display_frames_as_gif(frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pgayn",
   "language": "python",
   "name": "pgayn"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
